Type-Directed Continuation Allocation

Suppose we translate two different source languages, L1 and L2, into the same intermediate language; can they safely interoperate in the same address space and under the same runtime system? If L1 supports first-class continuations (call/cc) and L2 does not, can L2 programs call arbitrary L1 functions? Would the fact of possibly calling L1 impose restrictions on the implementation strategy of L2? Can we compile L1 functions that do not invoke call/cc using more efficient techniques borrowed from the L2 implementation? Our view is that the implementation of a common intermediate language ought to support the so-called pay-as-you-go efficiency: first-order monomorphic functions should be compiled as efficiently as in C and assembly languages, even though they may be passed to arbitrary polymorphic functions that support advanced control primitives (e.g. call/cc). In this paper, we present a typed intermediate language with effect and resource annotations, ensuring the safety of inter-language calls while allowing the compiler to choose continuation allocation strategies.